package com.qingfeng.core.dao;

import com.github.pagehelper.PageInfo;
import com.qingfeng.core.config.database.BaseMapper;
import com.qingfeng.core.entity.Role;
import com.qingfeng.core.mapper.RoleMapper;
import com.qingfeng.core.utils.UuidUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.entity.Example;

import java.util.*;

/**
 * @description: 角色dao
 * @author:LWY
 * @date: 2017/10/16 9:51
 * @modified:
 */
@Repository
public class RoleDao extends BaseDao<Role> {

    @Autowired
    RoleMapper roleMapper;

    @Override
    protected BaseMapper<Role> getBaseMapper() {
        return roleMapper;
    }

    /**
     * 获取用户所有角色
     *
     * @param userinfo_id userinfo_id
     * @return
     */
    public List<Role> byUserinfo(String userinfo_id) {
        return roleMapper.byUserinfo(userinfo_id);
    }

    /**
     * 分页获取角色列表
     *
     * @param pageNum  页码
     * @param pageSize 每页条数
     * @param role     角色名
     * @param state    角色状态
     * @return
     */
    public PageInfo<Role> get(Integer pageNum, Integer pageSize, String role, String state) {
        Example example = new Example(Role.class);
        Example.Criteria criteria = example.createCriteria();
        if (StringUtils.isNotEmpty(role)) {
            criteria.andLike("role", "%" + role + "%");
        }
        if (StringUtils.isNotEmpty(state)) {
            criteria.andCondition("state=", state);
        }
        return super.get(pageNum, pageSize, example);
    }

    /**
     * 删除角色
     *
     * @param ids id集合
     */
    @Override
    public int del(String[] ids) {
        //先删除权限角色关联，再删除角色用户关联关系，后删除角色，注意顺序不能乱
        delPermission(ids);
        delUserinfo(ids);
        return super.del(ids);
    }

    /**
     * 删除关联用户
     *
     * @param ids
     */
    private void delUserinfo(String[] ids) {
        String s = Arrays.toString(ids);
        roleMapper.delUserinfo(s.substring(1, s.length() - 1));
    }

    /**
     * 删除关联权限
     *
     * @param ids
     */
    public void delPermission(String[] ids) {
        String s = Arrays.toString(ids);
        roleMapper.delPermission(s.substring(1, s.length() - 1));
    }

    /**
     * 保存角色
     *
     * @param id          角色id
     * @param role        角色名
     * @param description 描述
     * @param create_id   保存人id
     * @return 保存的id
     */
    public Role save(String id, String role, String description, String create_id) {
        Role r = new Role();
        r.setRole(role);
        r.setDescription(description);
        if (StringUtils.isNotEmpty(id)) {
            //修改
            r.setId(id);
            roleMapper.updateByPrimaryKeySelective(r);
        } else {
            //添加
            id = UuidUtil.generatorUUID();
            r.setId(id);
            r.setCreate_id(create_id);
            r.setCreate_time(new Date());
            roleMapper.insertSelective(r);
        }
        return roleMapper.selectByPrimaryKey(id);
    }

    /**
     * 保存授权
     *
     * @param role_id        角色id
     * @param permission_ids 权限id
     * @param create_id      创建者
     */
    public void savePermission(String role_id, String[] permission_ids, String create_id) {
        //先删除所有授权
        delPermission(new String[]{role_id});
        if (permission_ids == null) {
            return;
        }
        List<Map> list = new ArrayList<>();
        for (String permission_id : permission_ids) {
            Map<String, Object> map = new HashMap();
            map.put("role_id", role_id);
            map.put("permission_id", permission_id);
            map.put("create_id", create_id);
            list.add(map);
        }
        roleMapper.savePermission(list);
    }

    /**
     * 获取所有角色并且标记某用户有哪些角色
     *
     * @param userinfo_id
     * @return
     */
    public List<Map> forUserinfo(String userinfo_id) {
        return roleMapper.forUserinfo(userinfo_id);
    }
}
